// 本地存储服务
const API_CONFIG = require('../config/api.config.js')

class StorageService {
  constructor() {
    this.HISTORY_KEY = 'chat_reply_history'
    this.FAVORITES_KEY = 'chat_reply_favorites'
    this.FEEDBACK_KEY = 'chat_reply_feedback'
  }

  /**
   * 保存历史记录
   * @param {Object} record - 历史记录对象
   */
  async saveHistory(record) {
    try {
      const history = await this.getHistory()

      // 添加时间戳和ID
      record.id = Date.now()
      record.timestamp = new Date().toISOString()

      // 添加到列表开头
      history.unshift(record)

      // 限制历史记录数量
      if (history.length > API_CONFIG.MAX_HISTORY_RECORDS) {
        history.splice(API_CONFIG.MAX_HISTORY_RECORDS)
      }

      // 保存到本地存储
      wx.setStorageSync(this.HISTORY_KEY, history)

      return record.id
    } catch (error) {
      console.error('保存历史记录失败:', error)
      throw error
    }
  }

  /**
   * 获取历史记录
   * @returns {Promise<Array>} 历史记录数组
   */
  async getHistory() {
    try {
      const history = wx.getStorageSync(this.HISTORY_KEY)
      return history || []
    } catch (error) {
      console.error('获取历史记录失败:', error)
      return []
    }
  }

  /**
   * 删除历史记录
   * @param {number} id - 记录ID
   */
  async deleteHistory(id) {
    try {
      const history = await this.getHistory()
      const newHistory = history.filter(item => item.id !== id)
      wx.setStorageSync(this.HISTORY_KEY, newHistory)
      return true
    } catch (error) {
      console.error('删除历史记录失败:', error)
      throw error
    }
  }

  /**
   * 清空历史记录
   */
  async clearHistory() {
    try {
      wx.removeStorageSync(this.HISTORY_KEY)
      return true
    } catch (error) {
      console.error('清空历史记录失败:', error)
      throw error
    }
  }

  /**
   * 添加收藏
   * @param {Object} favorite - 收藏对象
   */
  async addFavorite(favorite) {
    try {
      const favorites = await this.getFavorites()

      // 添加时间戳和ID
      favorite.id = Date.now()
      favorite.timestamp = new Date().toISOString()

      // 检查是否超过限制
      if (favorites.length >= API_CONFIG.MAX_FAVORITES) {
        throw new Error(`收藏数量已达上限（${API_CONFIG.MAX_FAVORITES}条），请先清理旧收藏`)
      }

      // 添加到列表开头
      favorites.unshift(favorite)

      // 保存到本地存储
      wx.setStorageSync(this.FAVORITES_KEY, favorites)

      return favorite.id
    } catch (error) {
      console.error('添加收藏失败:', error)
      throw error
    }
  }

  /**
   * 获取收藏列表
   * @returns {Promise<Array>} 收藏数组
   */
  async getFavorites() {
    try {
      const favorites = wx.getStorageSync(this.FAVORITES_KEY)
      return favorites || []
    } catch (error) {
      console.error('获取收藏列表失败:', error)
      return []
    }
  }

  /**
   * 检查是否已收藏
   * @param {string} content - 回复内容
   * @returns {Promise<boolean>}
   */
  async isFavorited(content) {
    try {
      const favorites = await this.getFavorites()
      return favorites.some(item => item.content === content)
    } catch (error) {
      return false
    }
  }

  /**
   * 删除收藏
   * @param {number} id - 收藏ID
   */
  async deleteFavorite(id) {
    try {
      const favorites = await this.getFavorites()
      const newFavorites = favorites.filter(item => item.id !== id)
      wx.setStorageSync(this.FAVORITES_KEY, newFavorites)
      return true
    } catch (error) {
      console.error('删除收藏失败:', error)
      throw error
    }
  }

  /**
   * 搜索收藏
   * @param {string} keyword - 搜索关键词
   * @returns {Promise<Array>} 匹配的收藏数组
   */
  async searchFavorites(keyword) {
    try {
      const favorites = await this.getFavorites()
      if (!keyword || keyword.trim() === '') {
        return favorites
      }

      return favorites.filter(item =>
        item.content.includes(keyword) ||
        item.scenarioName.includes(keyword)
      )
    } catch (error) {
      console.error('搜索收藏失败:', error)
      return []
    }
  }

  /**
   * 保存反馈
   * @param {Object} feedback - 反馈对象
   */
  async saveFeedback(feedback) {
    try {
      const feedbackList = await this.getFeedbackList()

      feedback.id = Date.now()
      feedback.timestamp = new Date().toISOString()

      feedbackList.push(feedback)

      wx.setStorageSync(this.FEEDBACK_KEY, feedbackList)

      // 如果反馈超过10条，可以考虑上传到服务器
      if (feedbackList.length >= 10) {
        // TODO: 实现上传反馈到服务器的逻辑
        console.log('反馈数量达到10条，可以上传到服务器')
      }

      return feedback.id
    } catch (error) {
      console.error('保存反馈失败:', error)
      throw error
    }
  }

  /**
   * 获取反馈列表
   * @returns {Promise<Array>}
   */
  async getFeedbackList() {
    try {
      const feedbackList = wx.getStorageSync(this.FEEDBACK_KEY)
      return feedbackList || []
    } catch (error) {
      console.error('获取反馈列表失败:', error)
      return []
    }
  }

  /**
   * 清空所有数据
   */
  async clearAll() {
    try {
      wx.removeStorageSync(this.HISTORY_KEY)
      wx.removeStorageSync(this.FAVORITES_KEY)
      wx.removeStorageSync(this.FEEDBACK_KEY)
      return true
    } catch (error) {
      console.error('清空数据失败:', error)
      throw error
    }
  }
}

// 导出单例
const storageService = new StorageService()

module.exports = storageService
